use std::cell::RefCell;
use std::ffi::c_int;
use std::rc::Rc;
use std::vec::Splice;


#[derive(Debug)]
pub struct MyNode {
    data: Option<i32>,
    next: Option<Rc<RefCell<MyNode>>>
}

impl MyNode {
    pub fn new(data: i32) -> MyNode {
        MyNode {
            data: Some(data),
            next: None,
        }
    }
}




#[derive(Debug)]
pub struct Link {
    tail: Option<Rc<RefCell<MyNode>>>
}

impl Link {
    pub fn new() -> Link {
        Link {
           tail: None
        }
    }
    pub fn create_by_rear(&mut self, vec: Vec<i32>) {
        for i in vec {
            let node = Rc::new(RefCell::new(MyNode::new(i)));

            if let Some(tail) = &self.tail {
                // 最后一个节点的next指向第一个节点
                node.borrow_mut().next = Some(tail.borrow().next.clone().unwrap());
                // 当前的尾指针的下一个节点指向最后一个节点
                tail.borrow_mut().next = Some(node.clone());
                // 尾指针指向最后一个节点
                self.tail = Some(node.clone());
            } else {
                node.borrow_mut().next = Some(node.clone());
                self.tail = Some(node.clone());
            }
        }
        // dbg!(&self);
    }

    pub fn yuesefuhuan(&mut self, n: i32, m: i32) {
        let mut count = 1;

        let mut num = n;

        // 有bug的算法
        if let Some(tail) = &self.tail {
            // 回到第一个元素
            let mut current = tail.borrow().next.clone().unwrap();

            while num > 0  {
                if count == m {
                    count = 1;
                    // 出局
                    let next = current.borrow().next.clone().unwrap().borrow().next.clone().unwrap().clone();
                    current.borrow_mut().next = Some(next);

                    num -= 1;

                    &self.display();

                } else {
                    count += 1;
                    let next = current.borrow().next.clone().unwrap();

                    current = next;
                }
            }
        }
    }

    pub fn display(&mut self) {
        let mut flag = false;

        if let Some(tail) = &self.tail {
            let mut current = tail.borrow().next.clone().unwrap();

            loop {
                println!("{:?}", current.borrow().data.unwrap());
                if flag {
                    break;
                }

                // 根据借用规则，一个变量不能不同存在可变和不可变引用
                // current = current.borrow().next.clone().unwrap();
                let new_node = current.borrow().next.clone().unwrap();

                if  Rc::ptr_eq(&new_node, tail) {
                    flag = true;
                }

                current = new_node;
            }
        }
    }
}